package org.jiuling.local.tools.convert;

import org.jiuling.local.tools.verify.CharVerify;
import org.jiuling.local.tools.verify.StringVerify;

import java.util.Arrays;
import java.util.List;

/**
 * 字符串转换
 * @author 紫灵
 * @date 2022年02月08日 23时39分14秒
 */
@Deprecated
public class StringConvert {

    /** 私有构造函数，禁止创建对象 */
    private StringConvert(){}

    /**
     * 字符串转换为大写
     * @param str 字符串
     * @return 大写字符传
     */
    public static String toUpperCase(String str){
        if(StringVerify.isBlank(str)){
            return str;
        }
        char[] chars = str.toCharArray();
        StringBuilder stringBuilder = new StringBuilder();
        for (char cha : chars){
            stringBuilder.append(CharConvert.toUpperCase(cha));
        }
        return stringBuilder.toString();
    }

    /**
     * 字符串转换为小写
     * @param str 字符串
     * @return 小写字符串
     */
    public static String toLowerCase(String str){
        if(StringVerify.isBlank(str)){
            return str;
        }
        char[] chars = str.toCharArray();
        StringBuilder stringBuilder = new StringBuilder();
        for (char cha : chars){
            stringBuilder.append(CharConvert.toLowerCase(cha));
        }
        return stringBuilder.toString();
    }

    /**
     * 首字母转换为大写
     * @param str 字符串
     * @return 首字母大写的字符串
     */
    public static String initialsToUpperCase(String str){
        if(StringVerify.isBlank(str)){
            return str;
        }
        char[] chars = str.toCharArray();
        StringBuilder stringBuilder = new StringBuilder();
        // 判断长度是否为空
        if(chars.length != 0){
            // 转换第一个字符
            stringBuilder.append(CharConvert.toUpperCase(chars[0]));
            // 删除字符串中第一个字符
            stringBuilder.append(str.substring(1));
        }else {
            return str;
        }
        return stringBuilder.toString();
    }

    /**
     * 符号后首字母大写
     * TODO 第一个大小写依旧被转换了
     * @param symbol 符号
     * @param str 字符串
     * @return 符号后首字母大写的字符串
     */
    public static String afterSymbolInitialsToUpperCase(String symbol,String str){
        if(StringVerify.isBlank(str)){
            return str;
        }
        String[] strs = str.split(symbol);
        StringBuilder stringBuilder = new StringBuilder();
        for (String st : strs){
            if(!StringVerify.isBlank(st)){
                stringBuilder.append(initialsToUpperCase(st));
            }
            stringBuilder.append(symbol);
        }
        // 如果字符不为空则删除最后的字符
        if(!StringVerify.isBlank(symbol)) {
            stringBuilder.deleteCharAt(stringBuilder.length() - symbol.length());
        }
        return stringBuilder.toString();
    }

    /**
     * 分割单词（单词首字母为大写）
     * @param str 字符串
     * @param symbol 符号
     * @return 单词
     */
    public static String wordSegmentation(String str,String symbol){
        char[] chars = str.toCharArray();
        StringBuilder stringBuilder = new StringBuilder();
        for (char c : chars){
            if(CharVerify.isUpperCase(c)){
                // 增加空格
                stringBuilder.append(symbol);
            }
            stringBuilder.append(c);
        }
        // 如果第一个字符为大写则删除第一个空格
        if(CharVerify.isUpperCase(chars[0])){
            stringBuilder.deleteCharAt(symbol.length()-1);
        }
        return stringBuilder.toString();
    }

    /**
     * 替换
     * @param str 原字符串
     * @param replacement 替代字符串
     * @param targets 目标字符串
     * @return 新字符串
     */
    public static String replace(String str,String replacement,String... targets){
        for (String target : targets){
            str = str.replace(target,replacement);
        }
        return str;
    }

    /**
     * 补码转10进制带符号值
     * @param str 补码
     * @return 10进制字符串
     */
    public static int complementToDecimal(String str){
        List<String> map = Arrays.asList("0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F");
        String[] split = str.toUpperCase().split("");
        int source = 0;
        for (int i = 0;i<split.length;i++){
            source += map.indexOf(split[i]) * Math.pow(16,split.length-i-1);
        }

        if((source&0x80)>0){
            source = - ( ~(source-0x01) & 0x7F );
        }
        return source;
    }

    /**
     * 二进制转16进制
     * @param str 二进制字符串
     * @return 16进制字符串
     */
    public static String binarySystemTohexadecimal(String str){
        StringBuilder hexSB = new StringBuilder();
        int iTmp;
        for (int i = 0; i < str.length(); i+=4) {
            iTmp = 0;
            for (int j = 0; j < 4; j++) {
                iTmp += Integer.parseInt(str.substring(i+j,i+j+1)) << (4-j-1);
            }
            hexSB.append(Integer.toHexString(iTmp));
        }
        return hexSB.toString();
    }

    /**
     * 下标替换
     * @param str 字符串
     * @param replacementValue 替换值
     * @param subscript 下标
     * @return 替换后的字符串
     */
    public static String subscriptReplacement(String str,char replacementValue,int subscript){
        char[] chars = str.toCharArray();
        for (int i = 0;i < chars.length;i++){
            if(i == subscript){
                chars[i] = replacementValue;
            }
        }
        return String.valueOf(chars);
    }
}
